Vite plagin arxitekturasini o'rganib, dasturlash jarayonini yaxshilash uchun maxsus plaginlar yarating. Amaliy misollar orqali asosiy konsepsiyalarni o'zlashtiring.
Vite Plagin Arxitekturasini Tushunish: Maxsus Plaginlar Yaratish Bo'yicha Global Qo'llanma
Vite, chaqmoq tezligidagi yig'ish vositasi, frontend dasturlashda inqilob qildi. Uning tezligi va soddaligi asosan uning kuchli plagin arxitekturasi bilan bog'liq. Ushbu arxitektura dasturchilarga Vite funksionalligini kengaytirish va uni o'zlarining maxsus loyiha ehtiyojlariga moslashtirish imkonini beradi. Ushbu qo'llanma Vite plagin tizimini keng qamrovli o'rganishni ta'minlaydi, bu sizga o'z maxsus plaginlaringizni yaratish va dasturlash ish jarayonini optimallashtirish imkonini beradi.
Vite-ning Asosiy Tamoyillarini Tushunish
Plagin yaratishga kirishishdan oldin, Vite-ning asosiy tamoyillarini tushunib olish muhim:
- Talab bo'yicha kompilyatsiya: Vite kodni faqat brauzer tomonidan so'ralganda kompilyatsiya qiladi, bu ishga tushirish vaqtini sezilarli darajada qisqartiradi.
- Asl ESM: Vite dasturlash uchun asl ECMAScript modullaridan (ESM) foydalanadi, bu dasturlash jarayonida paketlash (bundling) zaruratini yo'q qiladi.
- Rollup-ga asoslangan Production Yig'ish: Production yig'ish uchun Vite yuqori darajada optimallashtirilgan Rollup paketlagichidan foydalanib, samarali va production uchun tayyor kod yaratadi.
Vite Ekotizimidagi Plaginlarning Roli
Vite plagin arxitekturasi yuqori darajada kengaytiriladigan qilib yaratilgan. Plaginlar quyidagilarni qila oladi:
- Kodni o'zgartirish (masalan, TypeScript-ni transpilyatsiya qilish, preprotsessorlar qo'shish).
- Maxsus fayllarni taqdim etish (masalan, statik aktivlarga ishlov berish, virtual modullar yaratish).
- Yig'ish jarayonini o'zgartirish (masalan, tasvirlarni optimallashtirish, service worker-lar yaratish).
- Vite CLI-ni kengaytirish (masalan, maxsus buyruqlar qo'shish).
Plaginlar Vite-ni oddiy o'zgartirishlardan tortib murakkab integratsiyalargacha bo'lgan turli loyiha talablariga moslashtirishning kalitidir.
Vite Plagin Arxitekturasi: Chuqur Tahlil
Vite plagini, aslida, o'zining xatti-harakatlarini belgilaydigan maxsus xususiyatlarga ega JavaScript obyektidir. Keling, asosiy elementlarni ko'rib chiqaylik:
Plagin Konfiguratsiyasi
`vite.config.js` (yoki `vite.config.ts`) fayli sizning Vite loyihangizni sozlaydigan joy bo'lib, qaysi plaginlardan foydalanishni ham o'z ichiga oladi. `plugins` opsiyasi plagin obyektlari massivini yoki plagin obyektlarini qaytaradigan funksiyalarni qabul qiladi.
// vite.config.js
import myPlugin from './my-plugin';
export default {
plugins: [
myPlugin(), // Plagin nusxasini yaratish uchun plagin funksiyasini chaqiring
],
};
Plagin Obyektining Xususiyatlari
Vite plagini obyekti yig'ish jarayonining turli bosqichlarida o'z xatti-harakatini belgilaydigan bir nechta xususiyatlarga ega bo'lishi mumkin. Eng keng tarqalgan xususiyatlarning tavsifi:
- name: Plagin uchun noyob nom. Bu talab qilinadi va nosozliklarni tuzatish hamda ziddiyatlarni hal qilishda yordam beradi. Misol: `'my-custom-plugin'`
- enforce: Plaginning bajarilish tartibini belgilaydi. Mumkin bo'lgan qiymatlar: `'pre'` (asosiy plaginlardan oldin ishlaydi), `'normal'` (standart), va `'post'` (asosiy plaginlardan keyin ishlaydi). Misol: `'pre'`
- config: Vite konfiguratsiya obyektini o'zgartirishga imkon beradi. U foydalanuvchi konfiguratsiyasini va muhitni (rejim va buyruq) qabul qiladi. Misol: `config: (config, { mode, command }) => { ... }`
- configResolved: Vite konfiguratsiyasi to'liq hal qilinganidan keyin chaqiriladi. Yakuniy konfiguratsiya obyektiga kirish uchun foydalidir. Misol: `configResolved(config) { ... }`
- configureServer: Dasturlash serveri nusxasiga (Connect/Express-ga o'xshash) kirish imkonini beradi. Maxsus middleware qo'shish yoki server xatti-harakatini o'zgartirish uchun foydalidir. Misol: `configureServer(server) { ... }`
- transformIndexHtml: `index.html` faylini o'zgartirishga imkon beradi. Skriptlar, uslublar yoki meta-teglar kiritish uchun foydalidir. Misol: `transformIndexHtml(html) { ... }`
- resolveId: Modul rezolyutsiyasini to'xtatib turish va o'zgartirishga imkon beradi. Maxsus modul rezolyutsiyasi mantig'i uchun foydalidir. Misol: `resolveId(source, importer) { ... }`
- load: Maxsus modullarni yuklash yoki mavjud modul tarkibini o'zgartirishga imkon beradi. Virtual modullar yoki maxsus yuklagichlar uchun foydalidir. Misol: `load(id) { ... }`
- transform: Modullarning manba kodini o'zgartiradi. Babel plagini yoki PostCSS plaginiga o'xshash. Misol: `transform(code, id) { ... }`
- buildStart: Yig'ish jarayonining boshida chaqiriladi. Misol: `buildStart() { ... }`
- buildEnd: Yig'ish jarayoni tugaganidan keyin chaqiriladi. Misol: `buildEnd() { ... }`
- closeBundle: Paket diskka yozilganidan keyin chaqiriladi. Misol: `closeBundle() { ... }`
- writeBundle: Paketni diskka yozishdan oldin chaqirilib, o'zgartirishga imkon beradi. Misol: `writeBundle(options, bundle) { ... }`
- renderError: Dasturlash paytida maxsus xatolik sahifalarini ko'rsatishga imkon beradi. Misol: `renderError(error, req, res) { ... }`
- handleHotUpdate: HMR ustidan nozik nazoratni ta'minlaydi. Misol: `handleHotUpdate({ file, server }) { ... }`
Plagin Hooklari va Bajarilish Tartibi
Vite plaginlari yig'ish jarayonining turli bosqichlarida ishga tushiriladigan bir qator hooklar orqali ishlaydi. Ushbu hooklarning qaysi tartibda bajarilishini tushunish samarali plaginlar yozish uchun juda muhimdir.
- config: Vite konfiguratsiyasini o'zgartirish.
- configResolved: Hal qilingan konfiguratsiyaga kirish.
- configureServer: Dasturlash serverini o'zgartirish (faqat dasturlash rejimida).
- transformIndexHtml: `index.html` faylini o'zgartirish.
- buildStart: Yig'ish jarayonining boshlanishi.
- resolveId: Modul ID'larini hal qilish.
- load: Modul tarkibini yuklash.
- transform: Modul kodini o'zgartirish.
- handleHotUpdate: Qaynoq Modul Almashinuvini (HMR) boshqarish.
- writeBundle: Chiqish paketini diskka yozishdan oldin o'zgartirish.
- closeBundle: Chiqish paketi diskka yozilganidan keyin chaqiriladi.
- buildEnd: Yig'ish jarayonining oxiri.
Birinchi Maxsus Vite Plaginingizni Yaratish
Keling, production yig'ishdagi har bir JavaScript faylining yuqori qismiga banner qo'shadigan oddiy Vite plaginini yaratamiz. Bu bannerda loyiha nomi va versiyasi bo'ladi.
Plagin Implementatsiyasi
// banner-plugin.js
import { readFileSync } from 'node:fs';
import { resolve } from 'node:path';
export default function bannerPlugin() {
return {
name: 'banner-plugin',
apply: 'build',
transform(code, id) {
if (!id.endsWith('.js')) {
return code;
}
const packageJsonPath = resolve(process.cwd(), 'package.json');
const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
const banner = `/**\n * Project: ${packageJson.name}\n * Version: ${packageJson.version}\n */\n`;
return banner + code;
},
};
}
Tushuntirish:
- name: Plagin nomini belgilaydi, 'banner-plugin'.
- apply: Ushbu plagin faqat yig'ish jarayonida ishlashi kerakligini belgilaydi. Buni 'build' ga o'rnatish uni faqat production uchun qiladi, bu dasturlash paytida keraksiz yuklamalarni oldini oladi.
- transform(code, id):
- Bu plaginning yadrosidir. U har bir modulning kodini (`code`) va ID'sini (`id`) ushlab qoladi.
- Shartli tekshiruv: `if (!id.endsWith('.js'))` o'zgartirish faqat JavaScript fayllariga qo'llanilishini ta'minlaydi. Bu xatolarga yoki kutilmagan xatti-harakatlarga olib kelishi mumkin bo'lgan boshqa fayl turlarini (masalan, CSS yoki HTML) qayta ishlashning oldini oladi.
- Package.json-ga kirish:
- `resolve(process.cwd(), 'package.json')` `package.json` fayliga mutlaq yo'lni yaratadi. `process.cwd()` joriy ishchi katalogni qaytaradi, bu buyruq qayerda bajarilishidan qat'i nazar to'g'ri yo'l ishlatilishini ta'minlaydi.
- `JSON.parse(readFileSync(packageJsonPath, 'utf-8'))` `package.json` faylini o'qiydi va tahlil qiladi. `readFileSync` faylni sinxron ravishda o'qiydi va `'utf-8'` Unicode belgilarini to'g'ri ishlash uchun kodlashni belgilaydi. Bu yerda sinxron o'qish maqbuldir, chunki u transform boshida bir marta sodir bo'ladi.
- Banner Yaratish:
- ``const banner = `/**\n * Project: ${packageJson.name}\n * Version: ${packageJson.version}\n */\n`;`` banner satrini yaratadi. U `package.json` faylidan loyiha nomi va versiyasini osongina joylashtirish uchun shablon literallaridan (backticks) foydalanadi. `\n` ketma-ketliklari bannerni to'g'ri formatlash uchun yangi qatorlar kiritadi. `*` belgisi `\*` bilan ekrandan chiqarilgan.
- Kodni o'zgartirish: `return banner + code;` bannerni asl JavaScript kodining boshiga qo'shadi. Bu transform funksiyasi tomonidan qaytarilgan yakuniy natijadir.
Plaginni Integratsiya Qilish
Plaginni `vite.config.js` faylingizga import qiling va uni `plugins` massiviga qo'shing:
// vite.config.js
import bannerPlugin from './banner-plugin';
export default {
plugins: [
bannerPlugin(),
],
};
Yig'ishni Ishga Tushirish
Endi `npm run build` (yoki loyihangizning yig'ish buyrug'i) ni ishga tushiring. Yig'ish tugagandan so'ng, `dist` katalogidagi yaratilgan JavaScript fayllarini tekshiring. Har bir faylning yuqori qismida bannerni ko'rasiz.
Ilg'or Plagin Texnikalari
Oddiy kod o'zgartirishlaridan tashqari, Vite plaginlari o'z imkoniyatlarini oshirish uchun yanada ilg'or texnikalardan foydalanishi mumkin.
Virtual Modullar
Virtual modullar plaginlarga diskda haqiqiy fayl sifatida mavjud bo'lmagan modullarni yaratishga imkon beradi. Bu dinamik tarkib yaratish yoki ilovaga konfiguratsiya ma'lumotlarini taqdim etish uchun foydalidir.
// virtual-module-plugin.js
export default function virtualModulePlugin(options) {
const virtualModuleId = 'virtual:my-module';
const resolvedVirtualModuleId = '\0' + virtualModuleId; // Rollup tomonidan ishlov berilishining oldini olish uchun \0 prefiksi bilan boshlanadi
return {
name: 'virtual-module-plugin',
resolveId(id) {
if (id === virtualModuleId) {
return resolvedVirtualModuleId;
}
},
load(id) {
if (id === resolvedVirtualModuleId) {
return `export default ${JSON.stringify(options)};`;
}
},
};
}
Ushbu misolda:
- `virtualModuleId` - bu virtual modulning identifikatorini ifodalovchi satr.
- `resolvedVirtualModuleId` - Rollup uni haqiqiy fayl sifatida qayta ishlashining oldini olish uchun `\0` bilan boshlanadi. Bu Rollup plaginlarida qo'llaniladigan kelishuvdir.
- `resolveId` modul rezolyutsiyasini to'xtatadi va agar so'ralgan ID `virtualModuleId` ga mos kelsa, hal qilingan virtual modul ID'sini qaytaradi.
- `load` modul yuklanishini to'xtatadi va agar so'ralgan ID `resolvedVirtualModuleId` ga mos kelsa, modul kodini qaytaradi. Bu holda, u `options` ni standart eksport sifatida eksport qiladigan JavaScript modulini yaratadi.
Virtual Moduldan Foydalanish
// vite.config.js
import virtualModulePlugin from './virtual-module-plugin';
export default {
plugins: [
virtualModulePlugin({ message: 'Virtual moduldan salom!' }),
],
};
// main.js
import message from 'virtual:my-module';
console.log(message.message); // Chiqish: Virtual moduldan salom!
Index HTML-ni O'zgartirish
`transformIndexHtml` hooki `index.html` faylini o'zgartirishga, masalan, skriptlar, uslublar yoki meta-teglar kiritishga imkon beradi. Bu analitikani kuzatishni qo'shish, ijtimoiy media metama'lumotlarini sozlash yoki HTML strukturasini moslashtirish uchun foydalidir.
// inject-script-plugin.js
export default function injectScriptPlugin() {
return {
name: 'inject-script-plugin',
transformIndexHtml(html) {
return html.replace(
'